/**
 * 订单控制器
 * 处理订单相关的HTTP请求
 */
const OrderService = require('../services/order.service');
const asyncHandler = require('../utils/asyncHandler');
const CustomError = require('../utils/customError');

class OrderController {
  /**
   * 提交订单
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 中间件函数
   */
  static submitOrder = asyncHandler(async (req, res, next) => {
    // 从请求体中获取订单数据
    const orderData = req.body;
    
    // 获取用户ID（实际项目中应从token中获取，这里为了测试方便从环境变量获取）
    const userId = process.env.TEST_USER_ID || 1;
    
    // 验证订单数据
    if (!orderData.orderDetailList || !Array.isArray(orderData.orderDetailList) || orderData.orderDetailList.length === 0) {
      throw new CustomError('订单明细不能为空', 400);
    }
    
    if (!orderData.totalAmount || orderData.totalAmount <= 0) {
      throw new CustomError('订单总金额必须大于0', 400);
    }
    
    if (!orderData.userAddressId) {
      throw new CustomError('收货地址不能为空', 400);
    }
    
    // 添加用户ID到订单数据
    orderData.userId = userId;
    
    // 调用服务层创建订单
    const result = await OrderService.createOrder(orderData);
    
    // 返回成功响应
    res.status(200).json({
      code: 200,
      message: '下单成功',
      data: result
    });
  });

  /**
   * 获取订单详情
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 中间件函数
   */
  static getOrderDetail = asyncHandler(async (req, res, next) => {
    // 从请求参数中获取订单号
    const { orderNo } = req.params;
    
    // 获取用户ID（实际项目中应从token中获取，这里为了测试方便从环境变量获取）
    const userId = process.env.TEST_USER_ID || 1;
    
    // 调用服务层获取订单详情
    const order = await OrderService.getOrderDetail(orderNo, userId);
    
    // 返回成功响应
    res.status(200).json({
      code: 200,
      message: '获取成功',
      data: order
    });
  });

  /**
   * 获取订单列表
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 中间件函数
   */
  static getOrderList = asyncHandler(async (req, res, next) => {
    // 从请求参数中获取分页信息和筛选条件
    const { page, limit } = req.params;
    const { orderStatus } = req.query;
    
    // 获取用户ID（实际项目中应从token中获取，这里为了测试方便从环境变量获取）
    const userId = process.env.TEST_USER_ID || 1;
    
    // 调用服务层获取订单列表
    const result = await OrderService.getOrderList(page, limit, userId, orderStatus);
    
    // 返回成功响应
    res.status(200).json({
      code: 200,
      message: '获取成功',
      data: result
    });
  });

  /**
   * 获取立即购买商品信息
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 中间件函数
   */
  static getImmediatePurchaseInfo = asyncHandler(async (req, res, next) => {
    // 从请求参数中获取商品ID
    const { goodsId } = req.params;
    const { blessing } = req.query;
    
    // 获取用户ID（实际项目中应从token中获取，这里为了测试方便从环境变量获取）
    const userId = process.env.TEST_USER_ID || 1;
    
    // 调用服务层获取立即购买商品信息
    const result = await OrderService.getImmediatePurchaseInfo(goodsId, userId, blessing);
    
    // 返回成功响应
    res.status(200).json({
      code: 200,
      message: '获取成功',
      data: result
    });
  });

  /**
   * 更新订单状态
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 中间件函数
   */
  static updateOrderStatus = asyncHandler(async (req, res, next) => {
    // 从请求参数中获取订单号和新状态
    const { orderNo } = req.params;
    const { status } = req.body;
    
    // 获取用户ID（实际项目中应从token中获取，这里为了测试方便从环境变量获取）
    const userId = process.env.TEST_USER_ID || 1;
    
    // 验证状态
    if (!status || status < 1 || status > 6) {
      throw new CustomError('无效的订单状态', 400);
    }
    
    // 调用服务层更新订单状态
    const result = await OrderService.updateOrderStatus(orderNo, userId, status);
    
    // 返回成功响应
    res.status(200).json({
      code: 200,
      message: '更新成功',
      data: result
    });
  });

  /**
   * 支付订单
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 中间件函数
   */
  static payOrder = asyncHandler(async (req, res, next) => {
    // 从请求参数中获取订单号
    const { orderNo } = req.params;
    
    // 获取用户ID（实际项目中应从token中获取，这里为了测试方便从环境变量获取）
    const userId = process.env.TEST_USER_ID || 1;
    
    // 调用服务层支付订单
    const result = await OrderService.payOrder(orderNo, userId);
    
    // 返回成功响应
    res.status(200).json({
      code: 200,
      message: '支付成功',
      data: result
    });
  });

  /**
   * 发货
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 中间件函数
   */
  static shipOrder = asyncHandler(async (req, res, next) => {
    // 从请求参数中获取订单号
    const { orderNo } = req.params;
    
    // 获取用户ID（实际项目中应从token中获取，这里为了测试方便从环境变量获取）
    const userId = process.env.TEST_USER_ID || 1;
    
    // 调用服务层发货
    const result = await OrderService.shipOrder(orderNo, userId);
    
    // 返回成功响应
    res.status(200).json({
      code: 200,
      message: '发货成功',
      data: result
    });
  });

  /**
   * 确认收货
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 中间件函数
   */
  static deliverOrder = asyncHandler(async (req, res, next) => {
    // 从请求参数中获取订单号
    const { orderNo } = req.params;
    
    // 获取用户ID（实际项目中应从token中获取，这里为了测试方便从环境变量获取）
    const userId = process.env.TEST_USER_ID || 1;
    
    // 调用服务层确认收货
    const result = await OrderService.deliverOrder(orderNo, userId);
    
    // 返回成功响应
    res.status(200).json({
      code: 200,
      message: '确认收货成功',
      data: result
    });
  });

  /**
   * 申请退款
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 中间件函数
   */
  static initiateRefund = asyncHandler(async (req, res, next) => {
    // 从请求参数中获取订单号
    const { orderNo } = req.params;
    
    // 获取用户ID（实际项目中应从token中获取，这里为了测试方便从环境变量获取）
    const userId = process.env.TEST_USER_ID || 1;
    
    // 调用服务层申请退款
    const result = await OrderService.initiateRefund(orderNo, userId);
    
    // 返回成功响应
    res.status(200).json({
      code: 200,
      message: '申请退款成功',
      data: result
    });
  });

  /**
   * 完成退款
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   * @param {Function} next - 中间件函数
   */
  static completeRefund = asyncHandler(async (req, res, next) => {
    // 从请求参数中获取订单号
    const { orderNo } = req.params;
    
    // 获取用户ID（实际项目中应从token中获取，这里为了测试方便从环境变量获取）
    const userId = process.env.TEST_USER_ID || 1;
    
    // 调用服务层完成退款
    const result = await OrderService.completeRefund(orderNo, userId);
    
    // 返回成功响应
    res.status(200).json({
      code: 200,
      message: '退款成功',
      data: result
    });
  });
}

module.exports = OrderController;